home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / bin_c / compile_to_jvm5.c < prev    next >
C/C++ Source or Header  |  1998-12-22  |  12KB  |  706 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.79)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9.  
  10.  
  11. T213 r213realloc(T213 C,T2 a1,T2 a2){
  12. T213 R=NULL;
  13. R=calloc(a2,sizeof(T0*));
  14. r213copy_from(R,C,(a1)-(1));
  15. return R;
  16. }
  17.  
  18.  
  19. void r213clear_all(T213 C,T2 a1){
  20. T2 _i=0;
  21. T0* _v=NULL;
  22. _i=a1;
  23. while (!((_i)<(0))) {
  24. (C)[_i]=(_v);
  25. _i=(_i)-(1);
  26. }
  27. }
  28.  
  29.  
  30. void r213set_all_with(T213 C,T0* a1,T2 a2){
  31. T2 _i=0;
  32. _i=a2;
  33. while (!((_i)<(0))) {
  34. (C)[_i]=(a1);
  35. _i=(_i)-(1);
  36. }
  37. }
  38.  
  39.  
  40. void r213copy_from(T213 C,T213 a1,T2 a2){
  41. T2 _i=0;
  42. _i=a2;
  43. while (!((_i)<(0))) {
  44. (C)[_i]=((a1)[_i]);
  45. _i=(_i)-(1);
  46. }
  47. }
  48.  
  49.  
  50. T339 r339realloc(T339 C,T2 a1,T2 a2){
  51. T339 R=NULL;
  52. R=calloc(a2,sizeof(T0*));
  53. r339copy_from(R,C,(a1)-(1));
  54. return R;
  55. }
  56.  
  57.  
  58. void r339set_all_with(T339 C,T0* a1,T2 a2){
  59. T2 _i=0;
  60. _i=a2;
  61. while (!((_i)<(0))) {
  62. (C)[_i]=(a1);
  63. _i=(_i)-(1);
  64. }
  65. }
  66.  
  67.  
  68. void r339copy_from(T339 C,T339 a1,T2 a2){
  69. T2 _i=0;
  70. _i=a2;
  71. while (!((_i)<(0))) {
  72. (C)[_i]=((a1)[_i]);
  73. _i=(_i)-(1);
  74. }
  75. }
  76.  
  77.  
  78. T382 r382realloc(T382 C,T2 a1,T2 a2){
  79. T382 R=NULL;
  80. R=calloc(a2,sizeof(T0*));
  81. r382copy_from(R,C,(a1)-(1));
  82. return R;
  83. }
  84.  
  85.  
  86. void r382set_all_with(T382 C,T0* a1,T2 a2){
  87. T2 _i=0;
  88. _i=a2;
  89. while (!((_i)<(0))) {
  90. (C)[_i]=(a1);
  91. _i=(_i)-(1);
  92. }
  93. }
  94.  
  95.  
  96. void r382copy_from(T382 C,T382 a1,T2 a2){
  97. T2 _i=0;
  98. _i=a2;
  99. while (!((_i)<(0))) {
  100. (C)[_i]=((a1)[_i]);
  101. _i=(_i)-(1);
  102. }
  103. }
  104.  
  105.  
  106. T328 r328realloc(T328 C,T2 a1,T2 a2){
  107. T328 R=NULL;
  108. R=calloc(a2,sizeof(T0*));
  109. r328copy_from(R,C,(a1)-(1));
  110. return R;
  111. }
  112.  
  113.  
  114. void r328copy_from(T328 C,T328 a1,T2 a2){
  115. T2 _i=0;
  116. _i=a2;
  117. while (!((_i)<(0))) {
  118. (C)[_i]=((a1)[_i]);
  119. _i=(_i)-(1);
  120. }
  121. }
  122.  
  123.  
  124. T93 r93realloc(T93 C,T2 a1,T2 a2){
  125. T93 R=NULL;
  126. R=calloc(a2,sizeof(T0*));
  127. r93copy_from(R,C,(a1)-(1));
  128. return R;
  129. }
  130.  
  131.  
  132. void r93set_all_with(T93 C,T0* a1,T2 a2){
  133. T2 _i=0;
  134. _i=a2;
  135. while (!((_i)<(0))) {
  136. (C)[_i]=(a1);
  137. _i=(_i)-(1);
  138. }
  139. }
  140.  
  141.  
  142. void r93copy_from(T93 C,T93 a1,T2 a2){
  143. T2 _i=0;
  144. _i=a2;
  145. while (!((_i)<(0))) {
  146. (C)[_i]=((a1)[_i]);
  147. _i=(_i)-(1);
  148. }
  149. }
  150.  
  151.  
  152. T330 r330realloc(T330 C,T2 a1,T2 a2){
  153. T330 R=NULL;
  154. R=calloc(a2,sizeof(T0*));
  155. r330copy_from(R,C,(a1)-(1));
  156. return R;
  157. }
  158.  
  159.  
  160. void r330set_all_with(T330 C,T0* a1,T2 a2){
  161. T2 _i=0;
  162. _i=a2;
  163. while (!((_i)<(0))) {
  164. (C)[_i]=(a1);
  165. _i=(_i)-(1);
  166. }
  167. }
  168.  
  169.  
  170. void r330copy_from(T330 C,T330 a1,T2 a2){
  171. T2 _i=0;
  172. _i=a2;
  173. while (!((_i)<(0))) {
  174. (C)[_i]=((a1)[_i]);
  175. _i=(_i)-(1);
  176. }
  177. }
  178.  
  179.  
  180. T196 r196realloc(T196 C,T2 a1,T2 a2){
  181. T196 R=NULL;
  182. R=calloc(a2,sizeof(T0*));
  183. r196copy_from(R,C,(a1)-(1));
  184. return R;
  185. }
  186.  
  187.  
  188. void r196set_all_with(T196 C,T0* a1,T2 a2){
  189. T2 _i=0;
  190. _i=a2;
  191. while (!((_i)<(0))) {
  192. (C)[_i]=(a1);
  193. _i=(_i)-(1);
  194. }
  195. }
  196.  
  197.  
  198. void r196copy_from(T196 C,T196 a1,T2 a2){
  199. T2 _i=0;
  200. _i=a2;
  201. while (!((_i)<(0))) {
  202. (C)[_i]=((a1)[_i]);
  203. _i=(_i)-(1);
  204. }
  205. }
  206.  
  207.  
  208. T100 r100realloc(T100 C,T2 a1,T2 a2){
  209. T100 R=NULL;
  210. R=calloc(a2,sizeof(T0*));
  211. r100copy_from(R,C,(a1)-(1));
  212. return R;
  213. }
  214.  
  215.  
  216. void r100copy_from(T100 C,T100 a1,T2 a2){
  217. T2 _i=0;
  218. _i=a2;
  219. while (!((_i)<(0))) {
  220. (C)[_i]=((a1)[_i]);
  221. _i=(_i)-(1);
  222. }
  223. }
  224.  
  225.  
  226. T6 r7has(T7* C,T3 a1){
  227. T6 R=0;
  228. R=(r7index_of(C,a1))!=(((C)->_count/*4*/)+(1));
  229. return R;
  230. }
  231.  
  232.  
  233. T8 r7to_external(T7* C){
  234. T8 R=0;
  235. /*[IF*/
  236. if(((C)->_capacity/*8*/)>((C)->_count/*4*/)){
  237. C->_count=((C)->_count/*4*/)+(1);
  238. /*[IF*/
  239. if((/*(IRF4.6item*/((C)->_storage/*0*/)[((C)->_count/*4*/)-(1)]/*)*/)!=('\0')){
  240. /*[IRF3.5put*/((C)->_storage/*0*/)[((C)->_count/*4*/)-(1)]=('\0');
  241. /*]*/
  242. }
  243. /*FI]*/
  244. }
  245. else{
  246. r7extend(C,'\0');
  247. }
  248. /*FI]*/
  249. C->_count=((C)->_count/*4*/)-(1);
  250. R=((void*)(C)->_storage/*0*/);
  251. return R;
  252. }
  253. /*No:STRING.remove_suffix*/
  254.  
  255.  
  256. void r7to_lower(T7* C){
  257. T2 _i=0;
  258. _i=(C)->_count/*4*/;
  259. while (!((_i)==(0))) {
  260. /*[IRF3.5put*/((C)->_storage/*0*/)[(_i)-(1)]=(r3to_lower(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  261. /*]*/
  262. _i=(_i)-(1);
  263. }
  264. }
  265. /*No:STRING.item*/
  266.  
  267.  
  268. T3 r7last(T7* C){
  269. T3 R=0;
  270. R=/*(IRF4.6item*/((C)->_storage/*0*/)[((C)->_count/*4*/)-(1)]/*)*/;
  271. return R;
  272. }
  273.  
  274.  
  275. T6 r7_px_60(T7* C,T0* a1){
  276. T6 R=0;
  277. T2 _i=0;
  278. _i=1;
  279. while (!(((((C)->_count/*4*/)<(_i))||(((((T7*)a1))->_count/*4*/)<(_i)))||((/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/)!=(/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i)-(1)]/*)*/)))) {
  280. _i=(_i)+(1);
  281. }
  282. /*[IF*/
  283. if(((C)->_count/*4*/)<(_i)){
  284. R=((((T7*)a1))->_count/*4*/)>=(_i);
  285. }
  286.  else if(((((T7*)a1))->_count/*4*/)<(_i)){
  287. R=0;
  288. }
  289. else{
  290. R=(((unsigned)(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/))<((unsigned)(/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i)-(1)]/*)*/)));
  291. }
  292. /*FI]*/
  293. return R;
  294. }
  295.  
  296.  
  297. void r7extend(T7* C,T3 a1){
  298. T2 _new_capacity=0;
  299. /*[IF*/
  300. if(((C)->_capacity/*8*/)>((C)->_count/*4*/)){
  301. }
  302.  else if(((C)->_capacity/*8*/)==(0)){
  303. C->_capacity=32;
  304. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T3));
  305. }
  306. else{
  307. _new_capacity=(2)*((C)->_capacity/*8*/);
  308. C->_storage=r9realloc((C)->_storage/*0*/,(C)->_capacity/*8*/,_new_capacity);
  309. C->_capacity=_new_capacity;
  310. }
  311. /*FI]*/
  312. C->_count=((C)->_count/*4*/)+(1);
  313. /*[IRF3.5put*/((C)->_storage/*0*/)[((C)->_count/*4*/)-(1)]=(a1);
  314. /*]*/
  315. }
  316. /*No:STRING.replace_all*/
  317.  
  318.  
  319. void r7copy(T7* C,T0* a1){
  320. C->_count=(((T7*)a1))->_count/*4*/;
  321. /*[IF*/
  322. if(((C)->_count/*4*/)>(0)){
  323. /*[IF*/
  324. if(((C)->_capacity/*8*/)<((C)->_count/*4*/)){
  325. C->_storage=calloc((C)->_count/*4*/,sizeof(T3));
  326. C->_capacity=(C)->_count/*4*/;
  327. }
  328. /*FI]*/
  329. r9copy_from((C)->_storage/*0*/,(((T7*)a1))->_storage/*0*/,((C)->_count/*4*/)-(1));
  330. }
  331. /*FI]*/
  332. }
  333.  
  334.  
  335. void r7swap(T7* C,T2 a1,T2 a2){
  336. T3 _tmp=0;
  337. _tmp=/*(IRF4.6item*/((C)->_storage/*0*/)[(a1)-(1)]/*)*/;
  338. /*[IRF3.5put*/((C)->_storage/*0*/)[(a1)-(1)]=(/*(IRF4.6item*/((C)->_storage/*0*/)[(a2)-(1)]/*)*/);
  339. /*]*/
  340. /*[IRF3.5put*/((C)->_storage/*0*/)[(a2)-(1)]=(_tmp);
  341. /*]*/
  342. }
  343.  
  344.  
  345. T2 r7hash_code(T7* C){
  346. T2 R=0;
  347. T2 _i=0;
  348. _i=(C)->_count/*4*/;
  349. /*[IF*/
  350. if((_i)>(5)){
  351. R=(_i)*(((unsigned char)/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  352. _i=5;
  353. }
  354. /*FI]*/
  355. while (!((_i)<=(0))) {
  356. R=((R)+(_i))+(((unsigned char)/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  357. _i=(_i)-(1);
  358. }
  359. R=(R)*((C)->_count/*4*/);
  360. return R;
  361. }
  362. /*No:STRING.put*/
  363. /*No:STRING.storage*/
  364.  
  365.  
  366. void r7remove_first(T7* C,T2 a1){
  367. /*[IF*/
  368. if((a1)>(0)){
  369. r7remove_between(C,1,a1);
  370. }
  371. /*FI]*/
  372. }
  373.  
  374.  
  375. void r7to_upper(T7* C){
  376. T2 _i=0;
  377. _i=(C)->_count/*4*/;
  378. while (!((_i)==(0))) {
  379. /*[IRF3.5put*/((C)->_storage/*0*/)[(_i)-(1)]=(r3to_upper(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  380. /*]*/
  381. _i=(_i)-(1);
  382. }
  383. }
  384.  
  385.  
  386. T0* r7twin(T7* C){
  387. T0* R=NULL;
  388. R=malloc(sizeof(*C));
  389. *((T7*)R)=M7;
  390. r7copy(((T7*)R),((T0*)C));
  391. return R;
  392. }
  393.  
  394.  
  395. void r7set_last(T7* C,T3 a1){
  396. /*[IF*/
  397. if((((C)->_count/*4*/)==(0))||((/*(IRF4.6item*/((C)->_storage/*0*/)[((C)->_count/*4*/)-(1)]/*)*/)!=(a1))){
  398. r7extend(C,a1);
  399. }
  400. /*FI]*/
  401. }
  402.  
  403.  
  404. void r7remove_last(T7* C,T2 a1){
  405. C->_count=((C)->_count/*4*/)-(a1);
  406. }
  407.  
  408.  
  409. T6 r7is_equal(T7* C,T0* a1){
  410. T6 R=0;
  411. /*[IF*/
  412. if((C)==((void*)(a1))){
  413. R=1;
  414. }
  415.  else if(((C)->_count/*4*/)==((((T7*)a1))->_count/*4*/)){
  416. R=r9fast_memcmp((C)->_storage/*0*/,(((T7*)a1))->_storage/*0*/,(C)->_count/*4*/);
  417. }
  418. /*FI]*/
  419. return R;
  420. }
  421.  
  422.  
  423. T6 r7has_suffix(T7* C,T0* a1){
  424. T6 R=0;
  425. T2 _i2=0;
  426. T2 _i1=0;
  427. /*[IF*/
  428. if(((((T7*)a1))->_count/*4*/)<=((C)->_count/*4*/)){
  429. _i1=(((C)->_count/*4*/)-((((T7*)a1))->_count/*4*/))+(1);
  430. _i2=1;
  431. while (!((((_i1)>((C)->_count/*4*/))||((_i2)>((((T7*)a1))->_count/*4*/)))||((/*(IRF4.6item*/((C)->_storage/*0*/)[(_i1)-(1)]/*)*/)!=(/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i2)-(1)]/*)*/)))) {
  432. _i1=(_i1)+(1);
  433. _i2=(_i2)+(1);
  434. }
  435. R=(_i1)>((C)->_count/*4*/);
  436. }
  437. /*FI]*/
  438. return R;
  439. }
  440.  
  441.  
  442. void r7remove_between(T7* C,T2 a1,T2 a2){
  443. T2 _i=0;
  444. _i=a2;
  445. while (!((_i)>=((C)->_count/*4*/))) {
  446. /*[IRF3.5put*/((C)->_storage/*0*/)[(((a1)+(_i))-(a2))-(1)]=(/*(IRF4.6item*/((C)->_storage/*0*/)[((_i)+(1))-(1)]/*)*/);
  447. /*]*/
  448. _i=(_i)+(1);
  449. }
  450. C->_count=((C)->_count/*4*/)-(((a2)-(a1))+(1));
  451. }
  452.  
  453.  
  454. T6 r7same_as(T7* C,T0* a1){
  455. T6 R=0;
  456. T2 _i=0;
  457. /*[IF*/
  458. if((a1)==((void*)(C))){
  459. R=1;
  460. }
  461. else{
  462. /*[IF*/
  463. if(((((T7*)a1))->_count/*4*/)!=((C)->_count/*4*/)){
  464. }
  465. else{
  466. _i=(C)->_count/*4*/;
  467. while (!(((_i)==(0))||(!(r3same_as(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/,/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i)-(1)]/*)*/))))) {
  468. _i=(_i)-(1);
  469. }
  470. R=(_i)==(0);
  471. }
  472. /*FI]*/
  473. }
  474. /*FI]*/
  475. return R;
  476. }
  477.  
  478.  
  479. T2 r7index_of_string(T7* C,T0* a1){
  480. T2 R=0;
  481. T2 _i3=0;
  482. T2 _i2=0;
  483. T2 _i1=0;
  484. T6 _stop=0;
  485. _i1=1;
  486. _i2=(((T7*)a1))->_count/*4*/;
  487. _i3=_i2;
  488. while (!((R)!=(0))) {
  489. /*[IF*/
  490. if((_i2)>((C)->_count/*4*/)){
  491. R=((C)->_count/*4*/)+(1);
  492. }
  493. else{
  494. _stop=0;
  495. while (!(_stop)) {
  496. /*[IF*/
  497. if((_i3)==(0)){
  498. _stop=1;
  499. R=_i1;
  500. }
  501.  else if((/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i3)-(1)]/*)*/)!=(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i2)-(1)]/*)*/)){
  502. _stop=1;
  503. }
  504. /*FI]*/
  505. _i3=(_i3)-(1);
  506. _i2=(_i2)-(1);
  507. }
  508. }
  509. /*FI]*/
  510. _i1=(_i1)+(1);
  511. _i3=(((T7*)a1))->_count/*4*/;
  512. _i2=((_i1)+(_i3))-(1);
  513. }
  514. return R;
  515. }
  516.  
  517.  
  518. void r7prepend(T7* C,T0* a1){
  519. T2 _old_count=0;
  520. T2 _i=0;
  521. _old_count=(C)->_count/*4*/;
  522. _i=(((T7*)a1))->_count/*4*/;
  523. while (!((_i)==(0))) {
  524. r7extend(C,'\40');
  525. _i=(_i)-(1);
  526. }
  527. _i=(C)->_count/*4*/;
  528. while (!((_old_count)==(0))) {
  529. /*[IRF3.5put*/((C)->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((C)->_storage/*0*/)[(_old_count)-(1)]/*)*/);
  530. /*]*/
  531. _i=(_i)-(1);
  532. _old_count=(_old_count)-(1);
  533. }
  534. _i=(((T7*)a1))->_count/*4*/;
  535. while (!((_i)==(0))) {
  536. /*[IRF3.5put*/((C)->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((((T7*)a1))->_storage/*0*/)[(_i)-(1)]/*)*/);
  537. /*]*/
  538. _i=(_i)-(1);
  539. }
  540. }
  541. /*No:STRING.first*/
  542.  
  543.  
  544. void r7to_hexadecimal(T7* C){
  545. T2 _value=0;
  546. T2 _new_count=0;
  547. T2 _k=0;
  548. T2 _i=0;
  549. _i=1;
  550. _k=((C)->_count/*4*/)%(4);
  551. /*[IF*/
  552. if((_k)>(0)){
  553. _new_count=1;
  554. }
  555. /*FI]*/
  556. while (!((_k)==(0))) {
  557. _value=((_value)*(2))+(r3value(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  558. _i=(_i)+(1);
  559. _k=(_k)-(1);
  560. }
  561. /*[IF*/
  562. if((_new_count)>(0)){
  563. /*[IRF3.5put*/((C)->_storage/*0*/)[(_new_count)-(1)]=(r2hexadecimal_digit(_value));
  564. /*]*/
  565. }
  566. /*FI]*/
  567. while (!((_i)>((C)->_count/*4*/))) {
  568. _value=r3value(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/);
  569. _i=(_i)+(1);
  570. _k=3;
  571. while (!((_k)==(0))) {
  572. _value=((_value)*(2))+(r3value(/*(IRF4.6item*/((C)->_storage/*0*/)[(_i)-(1)]/*)*/));
  573. _i=(_i)+(1);
  574. _k=(_k)-(1);
  575. }
  576. _new_count=(_new_count)+(1);
  577. /*[IRF3.5put*/((C)->_storage/*0*/)[(_new_count)-(1)]=(r2hexadecimal_digit(_value));
  578. /*]*/
  579. }
  580. C->_count=_new_count;
  581. }
  582. /*No:STRING.count*/
  583.  
  584.  
  585. void r7add_first(T7* C,T3 a1){
  586. T2 _i=0;
  587. r7extend(C,'\40');
  588. _i=(C)->_count/*4*/;
  589. while (!((_i)==(1))) {
  590. /*[IRF3.5put*/((C)->_storage/*0*/)[(_i)-(1)]=(/*(IRF4.6item*/((C)->_storage/*0*/)[((_i)-(1))-(1)]/*)*/);
  591. /*]*/
  592. _i=(_i)-(1);
  593. }
  594. /*[IRF3.5put*/((C)->_storage/*0*/)[(1)-(1)]=(a1);
  595. /*]*/
  596. }
  597.  
  598.  
  599. T6 r7has_string(T7* C,T0* a1){
  600. T6 R=0;
  601. R=(r7index_of_string(C,a1))!=(((C)->_count/*4*/)+(1));
  602. return R;
  603. }
  604.  
  605.  
  606. void r7make(T7* C,T2 a1){
  607. /*[IF*/
  608. if((a1)>(0)){
  609. /*[IF*/
  610. if(((C)->_capacity/*8*/)<(a1)){
  611. C->_storage=calloc(a1,sizeof(T3));
  612. C->_capacity=a1;
  613. }
  614. /*FI]*/
  615. }
  616. /*FI]*/
  617. C->_count=0;
  618. }
  619.  
  620.  
  621. void r7append(T7* C,T0* a1){
  622. T2 _needed_capacity=0;
  623. T2 _other_count=0;
  624. _other_count=(((T7*)a1))->_count/*4*/;
  625. _needed_capacity=((C)->_count/*4*/)+(_other_count);
  626. /*[IF*/
  627. if(((C)->_capacity/*8*/)<(_needed_capacity)){
  628. /*[IF*/
  629. if(((C)->_capacity/*8*/)==(0)){
  630. C->_capacity=_needed_capacity;
  631. C->_storage=calloc((C)->_capacity/*8*/,sizeof(T3));
  632. }
  633. else{
  634. C->_storage=r9realloc((C)->_storage/*0*/,(C)->_capacity/*8*/,_needed_capacity);
  635. C->_capacity=_needed_capacity;
  636. }
  637. /*FI]*/
  638. }
  639. /*FI]*/
  640. r9copy_at((C)->_storage/*0*/,(C)->_count/*4*/,(((T7*)a1))->_storage/*0*/,_other_count);
  641. C->_count=_needed_capacity;
  642. }
  643. /*No:STRING.clear*/
  644. /*No:STRING.empty*/
  645.  
  646.  
  647. T2 r7index_of(T7* C,T3 a1){
  648. T2 R=0;
  649. R=(1)+(r9fast_index_of((C)->_storage/*0*/,a1,((C)->_count/*4*/)-(1)));
  650. return R;
  651. }
  652. /*No:STRING.capacity*/
  653.  
  654.  
  655. void r79add_last(T79* C,T0* a1){
  656. T2 _new_capacity=0;
  657. /*[IF*/
  658. if(((C)->_capacity/*4*/)<((r79count(C))+(1))){
  659. /*[IF*/
  660. if(((C)->_capacity/*4*/)==(0)){
  661. C->_capacity=16;
  662. C->_storage=calloc((C)->_capacity/*4*/,sizeof(T0*));
  663. }
  664. else{
  665. _new_capacity=(2)*((C)->_capacity/*4*/);
  666. C->_storage=r80realloc((C)->_storage/*0*/,(C)->_capacity/*4*/,_new_capacity);
  667. C->_capacity=_new_capacity;
  668. }
  669. /*FI]*/
  670. }
  671. /*FI]*/
  672. C->_upper=((C)->_upper/*8*/)+(1);
  673. /*[IRF3.6put*/{T79* C1=C;
  674. T0* b1=a1;
  675. T2 b2=(C)->_upper/*8*/;
  676. ((C1)->_storage/*0*/)[(b2)-((C1)->_lower/*12*/)]=(b1);
  677. }/*]*/
  678. }
  679.  
  680.  
  681. T0* r79item(T79* C,T2 a1){
  682. T0* R=NULL;
  683. R=((C)->_storage/*0*/)[(a1)-((C)->_lower/*12*/)];
  684. return R;
  685. }
  686.  
  687.  
  688. T0* r79first(T79* C){
  689. T0* R=NULL;
  690. R=r79item(C,(C)->_lower/*12*/);
  691. return R;
  692. }
  693.  
  694.  
  695. T2 r79count(T79* C){
  696. T2 R=0;
  697. R=(((C)->_upper/*8*/)-((C)->_lower/*12*/))+(1);
  698. return R;
  699. }
  700. /*No:ARRAY[CREATION_CLAUSE].lower*/
  701. /*No:ARRAY[CREATION_CLAUSE].upper*/
  702. /*No:ARRAY[CREATION_CLAUSE].capacity*/
  703. /*No:ARRAY[CREATION_CLAUSE].put*/
  704. /*No:ARRAY[CREATION_CLAUSE].storage*/
  705.  
  706.